/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package fachada;

import EnderecoEstoque.EnderecoEstoque;
import EnderecoEstoque.EnderecoEstoqueJaCadastradoException;
import EnderecoEstoque.EnderecoEstoqueNaoCadastradoException;
import EnderecoEstoque.RepositorioEnderecoEstoque;
import Nivel.Nivel;
import Nivel.NivelNaoCadastradoException;
import Nivel.RepositorioNivel;
import cargo.Cargo;
import cargo.RepositorioCargo;
import categoria.Categoria;
import categoria.CategoriaNaoCadastradoException;
import categoria.RepositorioCategoria;
import compra.Compra;
import compra.RepositorioCompra;
import controladores.ControladorCargo;
import controladores.ControladorCategoria;
import controladores.ControladorCompra;
import controladores.ControladorDescricaoProduto;
import controladores.ControladorEmpresa;
import controladores.ControladorEnderecoEstoque;
import controladores.ControladorEntrada;
import controladores.ControladorFuncionario;
import controladores.ControladorNivel;
import controladores.ControladorPermissao;
import controladores.ControladorPermissaoUsuario;
import controladores.ControladorProduto;
import controladores.ControladorSetor;
import controladores.ControladorSetorEmpresa;
import controladores.ControladorSolicitacaoCompra;
import controladores.ControladorStatusProduto;
import controladores.ControladorSubCategoria;
import controladores.ControladorSubSetor;
import controladores.ControladorUnidadeMedida;
import descricaoProduto.DescricaoProduto;
import descricaoProduto.DescricaoProdutoJaCadastradoExeption;
import descricaoProduto.DescricaoProdutoNaoCadastradoException;
import descricaoProduto.RepositorioDescricaoProduto;
import empresa.Empresa;
import empresa.RepositorioEmpresa;
import entrada.Entrada;
import entrada.RepositorioEntrada;
import fornecedor.CadastroFornecedor;
import controladores.ControladorFornecedor;
import fornecedor.Fornecedor;
import fornecedor.FornecedorNaoCadastradoException;
import fornecedor.RepositorioFornecedor;
import funcionario.Funcionario;
import funcionario.RepositorioFuncionario;
import java.sql.Date;
import java.util.List;
import permissao.Permissao;
import permissao.RepositorioPermissao;
import permissaoUsuario.PermissaoUsuario;
import permissaoUsuario.PermissaoUsuarioJaCadastradoException;
import permissaoUsuario.RepositorioPermissaoUsuario;
import produto.Produto;
import produto.RepositorioProduto;
import setor.RepositorioSetor;
import setor.Setor;
import setor.SetorNaoCadastradoException;
import setorEmpresa.RepositorioSetorEmpresa;
import setorEmpresa.SetorEmpresa;
import solicitacaoCompra.CadastroSolicitacaoCompra;
import solicitacaoCompra.RepositorioSolicitacaoCompra;
import solicitacaoCompra.SolicitacaoCompra;
import statusProduto.RepositorioStatusProduto;
import statusProduto.StatusProduto;
import subCategoria.SubCategoria;
import subCategoria.SubCategoriaNaoCadastradoException;
import unidadeMedida.UnidadeMedidaNaoCadastradoException;
import util.CamposInvalidosException;
import util.ErroAcessoRepositorioException;
import util.CamposObrigatoriosException;
import produto.ProdutoJaCadastradoException;
import produto.ProdutoNaoCadastradoException;
import subCategoria.RepositorioSubCategoria;
import subSetor.RepositorioSubSetor;
import subSetor.SubSetor;
import subSetor.SubSetorNaoCadastradoException;
import unidadeMedida.RepositorioUnidadeMedida;
import unidadeMedida.UnidadeMedida;

/**
 *
 * @author Alberto
 */
public class FachadaBDR {

    // Objeto statico da classe FachadaBDR
    public static FachadaBDR objInstancia = null;
    
    // Objeto funcionario que ira guardar o funcionario logado
    public static Funcionario objFuncionario = null;
    
    
    // Repositorios do meu Sistema
    private RepositorioProduto objRepositorioProduto = null;
    private RepositorioDescricaoProduto objRepositorioDescricaoProduto = null;
    private RepositorioSubCategoria objRepositorioSubCategoria = null;
    private RepositorioCategoria objRepositorioCategoria = null;
    private RepositorioSetor objRepositorioSetor = null;
    private RepositorioEnderecoEstoque objRepositorioEnderecoEstoque = null;
    private RepositorioFornecedor objRepositorioFornecedor = null;
    private RepositorioNivel objRepositorioNivel = null;
    private RepositorioSubSetor objRepositorioSubSetor = null;
    private RepositorioStatusProduto objRepositorioStatusProduto = null;
    private RepositorioEmpresa objRepositorioEmpresa = null;
    private RepositorioSetorEmpresa objRepositorioSetorEmpresa = null;
    private RepositorioCargo objRepositorioCargo = null;
    private RepositorioPermissao objRepositorioPermissao = null;
    private RepositorioFuncionario objRepositorioFuncionario = null;
    private RepositorioSolicitacaoCompra objRepositorioSolicitacaoCompra = null;
    private RepositorioCompra objRepositorioCompra = null;
    private RepositorioUnidadeMedida objRepositorioUnidadeMedida = null;
    private RepositorioPermissaoUsuario objRepositorioPermissaoUsuario = null;
    private RepositorioEntrada objRepositorioEntrada = null;

    public static FachadaBDR getInstancia() throws ErroAcessoRepositorioException {
        if (objInstancia == null) {
            objInstancia = new FachadaBDR();
        }
        return objInstancia;
    }
    
    
    
    public static Funcionario getFuncionario(Funcionario objFunc){
        if(objFuncionario == null)
            objFuncionario = objFunc;
        
        return objFuncionario;
    }

    private FachadaBDR() throws ErroAcessoRepositorioException {
        //Criando os objetos repositorios e passando a seção e o objTransaction
        this.objRepositorioProduto              = new RepositorioProduto();
        this.objRepositorioDescricaoProduto     = new RepositorioDescricaoProduto();
        this.objRepositorioSubCategoria         = new RepositorioSubCategoria();
        this.objRepositorioCategoria            = new RepositorioCategoria();
        this.objRepositorioSetor                = new RepositorioSetor();
        this.objRepositorioEnderecoEstoque      = new RepositorioEnderecoEstoque();
        this.objRepositorioFornecedor           = new RepositorioFornecedor();
        this.objRepositorioNivel                = new RepositorioNivel();
        this.objRepositorioFornecedor           = new RepositorioFornecedor();
        this.objRepositorioSubSetor             = new RepositorioSubSetor();
        this.objRepositorioStatusProduto        = new RepositorioStatusProduto();
        this.objRepositorioEmpresa              = new RepositorioEmpresa();
        this.objRepositorioSetorEmpresa         = new RepositorioSetorEmpresa();
        this.objRepositorioCargo                = new RepositorioCargo();
        this.objRepositorioPermissao            = new RepositorioPermissao();
        this.objRepositorioFuncionario          = new RepositorioFuncionario();
        this.objRepositorioSolicitacaoCompra    = new RepositorioSolicitacaoCompra();
        this.objRepositorioCompra               = new RepositorioCompra();
        this.objRepositorioUnidadeMedida        = new RepositorioUnidadeMedida();
        this.objRepositorioPermissaoUsuario     = new RepositorioPermissaoUsuario();  
        this.objRepositorioEntrada              = new RepositorioEntrada();
    }

    /***************************************
     *** MÉTODOS DE PRODUTO ***************
     **************************************/
    
    /**
     * Método que ira cadastrar o Produto no banco
     * 
     * @param objProduto
     * @throws ProdutoJaCadastradoException
     * @throws CamposObrigatoriosException
     * @throws ErroAcessoRepositorioException
     */
    public void cadastrarProduto(Produto objProduto) throws ProdutoJaCadastradoException, CamposObrigatoriosException, ErroAcessoRepositorioException {
        // Iniciando os controladores
        ControladorProduto objControladorProduto = new ControladorProduto(this.objRepositorioProduto);

        // Cadastrando o objeto passado
        objControladorProduto.cadastrar(objProduto);
    }

    /**
     * Método ira atualiar os produtos no banco
     *
     * @param objProduto
     * @throws ProdutoNaoCadastradoException
     * @throws CamposObrigatoriosException
     * @throws ErroAcessoRepositorioException
     */
    public void atualizarProduto(Produto objProduto) throws ProdutoNaoCadastradoException, ProdutoJaCadastradoException, CamposObrigatoriosException, ErroAcessoRepositorioException {
        // Iniciando os controladores
        ControladorProduto objControladorProduto = new ControladorProduto(this.objRepositorioProduto);
        // Cadastrando o objeto passado
        objControladorProduto.atualizar(objProduto);
    }

    /**
     * Metodo que ira produrar o Produto
     *
     * @param int idProduto
     * @return Produto
     */
    public Produto procurarProduto(int idProduto) throws ProdutoNaoCadastradoException, ErroAcessoRepositorioException {
        // Iniciando os controladores
        ControladorProduto objControladorProduto = new ControladorProduto(this.objRepositorioProduto);

        // Cadastrando o objeto passado
        return objControladorProduto.procurar(idProduto);
    }

    /**
     * Metodo que ira listar os Produtos
     *
     * @return Collection
     */
    public List<Produto> listarProduto(String strComplemento) throws Exception, ErroAcessoRepositorioException {
        // Iniciando os controladores
        ControladorProduto objControladorProduto = new ControladorProduto(this.objRepositorioProduto);
        
        // Cadastrando o objeto passado
        return objControladorProduto.listar(strComplemento);
    }

    /**
     * Método que ira remover o produto do banco
     *
     * @param idProduto
     */
    public void removerProduto(int idProduto) throws ProdutoNaoCadastradoException, ErroAcessoRepositorioException {
        // Iniciando os controladores
        ControladorProduto objControladorProduto = new ControladorProduto(this.objRepositorioProduto);

        // Cadastrando o objeto passado
        objControladorProduto.remover(idProduto);
    }

    /**
     * Método que verifica se já existe um produto com a nota informada
     *
     * @param numeroNota
     * @return boolean
     */
    public boolean existePorNumeroNota(String numeroNota) throws ErroAcessoRepositorioException {
        // Iniciando os controladores
        ControladorProduto objControladorProduto = new ControladorProduto(this.objRepositorioProduto);

        // Cadastrando o objeto passado
        return objControladorProduto.existePorNumeroNota(numeroNota);
    }

    /*****************************************************************
     ******** FIM DOS MÉTODOS DE PRODUTO *****************
     *****************************************************************/
    /*****************************************************************
     ******** INICIO DOS MÉTODOS DE DESCRIÇÃO PRODUTO *****************
     *****************************************************************/
    /**
     * Metodo que ira cadastrar o DescricaoProduto
     *
     * @param DescricaoProduto objDescricaoProduto
     * @return void
     */
    public void cadastrarDescricaoProduto(DescricaoProduto objDescricaoProduto) throws DescricaoProdutoNaoCadastradoException, DescricaoProdutoJaCadastradoExeption, CamposObrigatoriosException, ErroAcessoRepositorioException {
        // Iniciando os controladores
        ControladorDescricaoProduto objControladorDescricaoProduto = new ControladorDescricaoProduto(this.objRepositorioDescricaoProduto);

        // Cadastrando o objeto passado
        objControladorDescricaoProduto.cadastrar(objDescricaoProduto);
    }

    /**
     * Metodo que ira atua
     * lizar o DescricaoProduto
     *
     * @param DescricaoProduto objDescricaoProduto
     * @return void
     */
    public void atualizarDescricaoProduto(DescricaoProduto objDescricaoProduto) throws DescricaoProdutoNaoCadastradoException, DescricaoProdutoJaCadastradoExeption, CamposObrigatoriosException, ErroAcessoRepositorioException {
        // Iniciando os controladores
        ControladorDescricaoProduto objControladorDescricaoProduto = new ControladorDescricaoProduto(this.objRepositorioDescricaoProduto);

        // Cadastrando o objeto passado
        objControladorDescricaoProduto.atualizar(objDescricaoProduto);
    }

    /**
     * Metodo que ira produrar o DescricaoProduto
     *
     * @param int idDescricaoProduto
     * @return void
     */
    public DescricaoProduto procurarDescricaoProduto(int idDescricaoProduto) throws DescricaoProdutoNaoCadastradoException, ErroAcessoRepositorioException {
        // Iniciando os controladores
        ControladorDescricaoProduto objControladorDescricaoProduto = new ControladorDescricaoProduto(this.objRepositorioDescricaoProduto);

        // Cadastrando o objeto passado
        return objControladorDescricaoProduto.procurar(idDescricaoProduto);
    }

    /**
     * Metodo que ira verificar a existência do DescricaoProduto
     *
     * @param int idDescricaoProduto
     * @return void
     */
    public boolean existeDescricaoProduto(int idDescricaoProduto) throws ErroAcessoRepositorioException {
        // Iniciando os controladores
        ControladorDescricaoProduto objControladorDescricaoProduto = new ControladorDescricaoProduto(this.objRepositorioDescricaoProduto);

        // Cadastrando o objeto passado
        return objControladorDescricaoProduto.existe(idDescricaoProduto);
    }

    /**
     * Metodo que ira listar os DescricaoProdutos
     *
     * @return Collection
     */
    public List<DescricaoProduto> listarDescricaoProduto(String strComplemento) throws Exception, ErroAcessoRepositorioException {
        // Iniciando os controladores
        ControladorDescricaoProduto objControladorDescricaoProduto = new ControladorDescricaoProduto(this.objRepositorioDescricaoProduto);

        // Cadastrando o objeto passado
        return objControladorDescricaoProduto.listar(strComplemento);
    }

    /**
     * Método que ira remover o DescricaoProduto do banco
     *
     * @param idDescricaoProduto
     */
    public void removerDescricaoProduto(int idDescricaoProduto) throws DescricaoProdutoNaoCadastradoException, ErroAcessoRepositorioException {
        // Iniciando os controladores
        ControladorDescricaoProduto objControladorDescricaoProduto = new ControladorDescricaoProduto(this.objRepositorioDescricaoProduto);

        // Cadastrando o objeto passado
        objControladorDescricaoProduto.remover(idDescricaoProduto);
    }

    /**
     * Metodo que ira listar os DescricaoProdutos
     *
     * @return Collection
     */
    public List<DescricaoProduto> listarDescricaoProdutoAtivos() throws Exception, ErroAcessoRepositorioException {
        // Iniciando os controladores
        ControladorDescricaoProduto objControladorDescricaoProduto = new ControladorDescricaoProduto(this.objRepositorioDescricaoProduto);

        // Cadastrando o objeto passado
        return objControladorDescricaoProduto.listarAtivos();
    }

    /**
     * Metodo que ira listar os Categorias
     *
     * @return Collection
     */
    public List<DescricaoProduto> procurarDescricaoProdutoPorDescricaoPorSubCategoria(String descricaoProduto, int idSubCategoria) throws CamposObrigatoriosException, Exception, ErroAcessoRepositorioException {
        // Iniciando os controladores
        ControladorDescricaoProduto objControladorDescricaoProduto = new ControladorDescricaoProduto(this.objRepositorioDescricaoProduto);

        // Cadastrando o objeto passado
        return objControladorDescricaoProduto.procurarPorDescricaoPorSubCategoria(descricaoProduto, idSubCategoria);
    }
    
    /**
     * Metodo que ira listar os DescricaoProdutos QUE ESTEJAM necessitando ser repostos
     *
     * @return Collection
     */
    public List<DescricaoProduto> listarDescricaoProdutoBaixoEstoque(String descricaoProduto, int idSubCategoria) throws Exception, ErroAcessoRepositorioException {
        // Iniciando os controladores
        ControladorDescricaoProduto objControladorDescricaoProduto = new ControladorDescricaoProduto(this.objRepositorioDescricaoProduto);

        // Cadastrando o objeto passado
        return objControladorDescricaoProduto.listarDescricaoProdutoBaixoEstoque(descricaoProduto, idSubCategoria);
    }
    /**
     * Metodo que ira listar os DescricaoProdutos QUE ESTEJAM necessitando ser repostos
     *
     * @return Collection
     */
    public List<DescricaoProduto> buscarDescricaoProdutoBaixoEstoque(String descricaoProduto, int idSubCategoria) throws Exception, ErroAcessoRepositorioException {
        // Iniciando os controladores
        ControladorDescricaoProduto objControladorDescricaoProduto = new ControladorDescricaoProduto(this.objRepositorioDescricaoProduto);

        // Cadastrando o objeto passado
        return objControladorDescricaoProduto.buscarDescricaoProdutoBaixoEstoque(descricaoProduto, idSubCategoria);
    }
    

    /*******************************************************************
     ****** FIM DOS MÉTODOS DE DESCRÇÃO PRODUTO ************************
     ******************************************************************/
    /************************************************************
     ****** INICIO DOS MÉTODOS DE SUB CATEGORIA *****************
     ************************************************************/
    /**
     * Metodo que ira cadastrar o SubCategoria
     * 
     * @param SubCategoria objSubCategoria
     * @return void
     */
    public void cadastrarSubCategoria(SubCategoria objSubCategoria) throws ErroAcessoRepositorioException, CamposObrigatoriosException {
        // Iniciando o controlador
        ControladorSubCategoria objControladorSubCategoria = new ControladorSubCategoria(this.objRepositorioSubCategoria);

        // Salvando os dados no banco
        objControladorSubCategoria.cadastrar(objSubCategoria);
    }

    /**
     * Metodo que ira cadastrar o SubCategoria
     * 
     * @param SubCategoria objSubCategoria
     * @return void
     */
    public void atualizarSubCategoria(SubCategoria objSubCategoria) throws ErroAcessoRepositorioException, CamposObrigatoriosException {
        // Iniciando o controlador
        ControladorSubCategoria objControladorSubCategoria = new ControladorSubCategoria(this.objRepositorioSubCategoria);

        // Salvando os dados no banco
        objControladorSubCategoria.atualizar(objSubCategoria);
    }

    /**
     * Metodo que ira produrar o SubCategoria
     *
     * @param int idSubCategoria
     * @return void
     */
    public SubCategoria procurarSubCategoria(int idSubCategoria) throws SubCategoriaNaoCadastradoException, ErroAcessoRepositorioException {
        // Iniciando o controlador
        ControladorSubCategoria objControladorSubCategoria = new ControladorSubCategoria(this.objRepositorioSubCategoria);

        // Salvando os dados no banco
        return objControladorSubCategoria.procurar(idSubCategoria);
    }

    /**
     * Metodo que ira verificar a existência do SubCategoria
     *
     * @param int idSubCategoria
     * @return void
     */
    public boolean existeSubCategoria(int idSubCategoria) throws ErroAcessoRepositorioException {
        // Iniciando o controlador
        ControladorSubCategoria objControladorSubCategoria = new ControladorSubCategoria(this.objRepositorioSubCategoria);

        // Salvando os dados no banco
        return objControladorSubCategoria.existe(idSubCategoria);
    }

    /**
     * Metodo que ira listar os SubCategorias
     *
     * @return Collection
     */
    public List<SubCategoria> listarSubCategoria(String strComplemento) throws Exception, ErroAcessoRepositorioException {
        // Iniciando o controlador
        ControladorSubCategoria objControladorSubCategoria = new ControladorSubCategoria(this.objRepositorioSubCategoria);

        // Salvando os dados no banco
        return objControladorSubCategoria.listar(strComplemento);
    }

    /**
     * Método que ira remover o SubCategoria do banco
     * 
     * @param idSubCategoria
     */
    public void removerSubCategoria(int idSubCategoria) throws SubCategoriaNaoCadastradoException, ErroAcessoRepositorioException {
        // Iniciando o controlador
        ControladorSubCategoria objControladorSubCategoria = new ControladorSubCategoria(this.objRepositorioSubCategoria);

        // Salvando os dados no banco
        objControladorSubCategoria.remover(idSubCategoria);
    }

    /**
     * Metodo que ira listar os SubCategorias
     *
     * @return Collection
     */
    public List<SubCategoria> listarSubCategoriaAtivo() throws Exception, ErroAcessoRepositorioException {
        // Iniciando o controlador
        ControladorSubCategoria objControladorSubCategoria = new ControladorSubCategoria(this.objRepositorioSubCategoria);

        // Salvando os dados no banco
        return objControladorSubCategoria.listarAtivo();
    }

    /**
     * Metodo que ira listar os Categorias
     *
     * @return Collection
     */
    public List<SubCategoria> procurarSubCategoriaPorDescricaoPorCategoria(String descricaoSubCategoria, int idCategoria) throws Exception, ErroAcessoRepositorioException {
        // Iniciando o controlador
        ControladorSubCategoria objControladorSubCategoria = new ControladorSubCategoria(this.objRepositorioSubCategoria);

        // Salvando os dados no banco
        return objControladorSubCategoria.procurarPorDescricaoPorCategoria(descricaoSubCategoria, idCategoria);
    }

    /**************************************************
     ******* FIM DOS MÉTODOS DE SUB CATEGORIA *********
     **************************************************/
    /*******************************************************************
     ******* INICIO DOS MÉTODOS DE CATEGORIA ***************************
     ******************************************************************/
    /**
     * Metodo que ira cadastrar o Categoria
     *
     * @param Categoria objCategoria
     * @return void
     */
    public void cadastrarCategoria(Categoria objCategoria) throws ErroAcessoRepositorioException, CamposObrigatoriosException {
        ControladorCategoria objControladorCategoria = new ControladorCategoria(this.objRepositorioCategoria);

        // Salvando no banco
        objControladorCategoria.cadastrar(objCategoria);
    }

    /**
     * Metodo que ira Atualizar o Categoria
     *
     * @param Categoria objCategoria
     * @return void
     */
    public void atualizarCategoria(Categoria objCategoria) throws ErroAcessoRepositorioException, CamposObrigatoriosException {
        ControladorCategoria objControladorCategoria = new ControladorCategoria(this.objRepositorioCategoria);

        // Salvando no banco
        objControladorCategoria.atualizar(objCategoria);
    }

    /**
     * Metodo que ira produrar o Categoria
     *
     * @param int idCategoria
     * @return void
     */
    public Categoria procurarCategoria(int idCategoria) throws CategoriaNaoCadastradoException, ErroAcessoRepositorioException, CamposObrigatoriosException {
        ControladorCategoria objControladorCategoria = new ControladorCategoria(this.objRepositorioCategoria);

        // Salvando no banco
        return objControladorCategoria.procurar(idCategoria);
    }

    /**
     * Metodo que ira verificar a existência do Categoria
     *
     * @param int idCategoria
     * @return void
     */
    public boolean existeCategoria(int idCategoria) throws ErroAcessoRepositorioException, CamposObrigatoriosException {
        ControladorCategoria objControladorCategoria = new ControladorCategoria(this.objRepositorioCategoria);

        // Salvando no banco
        return objControladorCategoria.existe(idCategoria);
    }

    /**
     * Metodo que ira listar os Categorias
     *
     * @return Collection
     */
    public List<Categoria> listarCategoria(String strComplemento) throws Exception, ErroAcessoRepositorioException {
        ControladorCategoria objControladorCategoria = new ControladorCategoria(this.objRepositorioCategoria);

        // Salvando no banco
        return objControladorCategoria.listar(strComplemento);
    }

    /**
     * Metodo que ira listar os Categorias
     *
     * @return Collection
     */
    public List<Categoria> procurarCategoriaPorDescricao(String descricao) throws Exception, ErroAcessoRepositorioException {
        ControladorCategoria objControladorCategoria = new ControladorCategoria(this.objRepositorioCategoria);

        // Salvando no banco
        return objControladorCategoria.procurarPorDescricao(descricao);
    }

    /**
     * Método que ira remover o Categoria do banco
     *
     * @param idCategoria
     */
    public void removerCategoria(int idCategoria) throws CategoriaNaoCadastradoException, ErroAcessoRepositorioException {
        ControladorCategoria objControladorCategoria = new ControladorCategoria(this.objRepositorioCategoria);

        // Salvando no banco
        objControladorCategoria.remover(idCategoria);
    }

    /**
     * Metodo que ira listar os Categorias
     *
     * @return Collection
     */
    public List<Categoria> listarCategoriaAtiva() throws Exception, ErroAcessoRepositorioException {
        ControladorCategoria objControladorCategoria = new ControladorCategoria(this.objRepositorioCategoria);

        // Salvando no banco
        return objControladorCategoria.listarAtiva();
    }

    /**************************************************
     ******** FIM DOS MÉTODOS DE CATEGORIA ************
     *************************************************/
    /*****************************************************
     ******** INICIO DOS MÉTODOS DE SETOR ****************
     *****************************************************/
    /**
     *
     * @param objRepositorioSetor
     * @throws ErroAcessoRepositorioException
     */
    public void cadastrarSetor(Setor objSetor) throws ErroAcessoRepositorioException, CamposObrigatoriosException {
        ControladorSetor objControladorSetor = new ControladorSetor(this.objRepositorioSetor);

        objControladorSetor.Cadastrar(objSetor);
    }

    /**
     * Metodo que ira cadastrar o Setor
     *
     * @param Setor objSetor
     * @return void
     */
    public void atualizarSetor(Setor objSetor) throws ErroAcessoRepositorioException, CamposObrigatoriosException {
        ControladorSetor objControladorSetor = new ControladorSetor(this.objRepositorioSetor);

        objControladorSetor.Atualizar(objSetor);

    }

    /**
     * Metodo que ira produrar o Setor
     *
     * @param int idSetor
     * @return void
     */
    public Setor procurarSetor(int idSetor) throws SetorNaoCadastradoException, ErroAcessoRepositorioException, CamposObrigatoriosException {
        ControladorSetor objControladorSetor = new ControladorSetor(this.objRepositorioSetor);

        return objControladorSetor.procurar(idSetor);

    }

    /**
     * Metodo que ira verificar a existência do Setor
     *
     * @param int idSetor
     * @return void
     */
    public boolean existeSetor(int idSetor) throws ErroAcessoRepositorioException, CamposObrigatoriosException {
        ControladorSetor objControladorSetor = new ControladorSetor(this.objRepositorioSetor);

        return objControladorSetor.existe(idSetor);

    }

    /**
     * Metodo que ira listar os Setors
     *
     * @return Collection
     */
    public List<Setor> listarSetor(String strComplemento) throws Exception, ErroAcessoRepositorioException, CamposObrigatoriosException {
        ControladorSetor objControladorSetor = new ControladorSetor(this.objRepositorioSetor);

        return objControladorSetor.listar(strComplemento);

    }

    /**
     * Método que ira remover o Setor do banco
     *
     * @param idSetor
     */
    public void removerSetor(int idSetor) throws SetorNaoCadastradoException, ErroAcessoRepositorioException, CamposObrigatoriosException {
        ControladorSetor objControladorSetor = new ControladorSetor(this.objRepositorioSetor);

        objControladorSetor.remover(idSetor);
    }

    /**
     * Metodo que ira listar o Setor
     *
     * @return Collection
     */
    public List<Setor> listarSetorAtivos() throws Exception, ErroAcessoRepositorioException {
        ControladorSetor objControladorSetor = new ControladorSetor(this.objRepositorioSetor);

        return objControladorSetor.listarAtivos();
    }

    /**
     * Metodo que ira listar os Categorias
     *
     * @return Collection
     */
    public List<Setor> procurarSetorPorDescricaoPorEnderecoEstoque(String descricaoSetor, int idEnderecoEstoque) throws Exception, ErroAcessoRepositorioException {
        ControladorSetor objControladorSetor = new ControladorSetor(this.objRepositorioSetor);

        return objControladorSetor.procurarPorDescricaoPorEnderecoEstoque(descricaoSetor, idEnderecoEstoque);
    }

    /*****************************************************
     ******** FIM DOS MÉTODOS DE SETOR ****************
     *****************************************************/
    /*****************************************************
     ******** INICIO DOS MÉTODOS DE ENDERECO ESTOQUE *****
     *****************************************************/
    /**
     * ******** INÍCIO DOS MÉTODOS DE ENDEREÇO ESTOQUE ************
     * @param objEnderecoEstoque
     * @throws EnderecoEstoqueJaCadastradoException
     * @throws CamposObrigatoriosException
     * @throws ErroAcessoRepositorioException 
     * 
     * METODO QUE CADASTRA OS ENDEREÇOS DOS ESTOQUES
     */
    public void cadastarEnderecoEstoque(EnderecoEstoque objEnderecoEstoque) throws EnderecoEstoqueJaCadastradoException, CamposObrigatoriosException, ErroAcessoRepositorioException {
        ControladorEnderecoEstoque objControladorEnderecoEStoque = new ControladorEnderecoEstoque(this.objRepositorioEnderecoEstoque);

        objControladorEnderecoEStoque.cadastar(objEnderecoEstoque);
    }

    /**
     * 
     * @param objenEnderecoEstoque
     * @throws EnderecoEstoqueJaCadastradoException
     * @throws CamposObrigatoriosException
     * @throws ErroAcessoRepositorioException 
     * 
     * MÉTODO QUE ATUALIZA OS ESNDEREÇOS DOS ESTOQUES
     */
    public void atualizarEnderecoEstoque(EnderecoEstoque objenEnderecoEstoque) throws EnderecoEstoqueJaCadastradoException, CamposObrigatoriosException, ErroAcessoRepositorioException {
        ControladorEnderecoEstoque objControladorEnderecoEstoque = new ControladorEnderecoEstoque(this.objRepositorioEnderecoEstoque);
        objControladorEnderecoEstoque.atualizar(objenEnderecoEstoque);
    }

    /**
     * 
     * @param idEnderecoEstoque
     * @return
     * @throws ErroAcessoRepositorioException
     * @throws CamposObrigatoriosException
     * @throws EnderecoEstoqueNaoCadastradoException 
     * 
     * MÉTODO QUE PROCURA OS ENDEREÇOS DOS ESTOQUES
     */
    public EnderecoEstoque procurarEnderecoEstoque(int idEnderecoEstoque) throws ErroAcessoRepositorioException, CamposObrigatoriosException, EnderecoEstoqueNaoCadastradoException {
        ControladorEnderecoEstoque objControladorEnderecoEstoque = new ControladorEnderecoEstoque(this.objRepositorioEnderecoEstoque);
        return objControladorEnderecoEstoque.procurar(idEnderecoEstoque);
    }

    /**
     * 
     * @param idEnderecoEstoque
     * @return
     * @throws ErroAcessoRepositorioException
     * @throws CamposObrigatoriosException 
     * 
     * MÉTODO QUE VERIFICA A EXISTÊNCIA DOS ENDEREÇOS DOS ESTOQUES
     */
    public boolean existeEnderecoEstoque(int idEnderecoEstoque) throws ErroAcessoRepositorioException, CamposObrigatoriosException {
        ControladorEnderecoEstoque objControladorEnderecoEstoque = new ControladorEnderecoEstoque(this.objRepositorioEnderecoEstoque);
        return objControladorEnderecoEstoque.existe(idEnderecoEstoque);
    }

    /**
     * 
     * @return
     * @throws Exception
     * @throws ErroAcessoRepositorioException 
     * 
     * MÉTODO QUE LISTA OS ENDEREÇOS DOS ESTOQUES
     */
    public List<EnderecoEstoque> listarEnderecoEstoque(String strComplemento) throws Exception, ErroAcessoRepositorioException {
        ControladorEnderecoEstoque objControladorEnderecoEstoque = new ControladorEnderecoEstoque(this.objRepositorioEnderecoEstoque);
        return objControladorEnderecoEstoque.listar(strComplemento);
    }

    /**
     * 
     * @param idEnderecoEstoque
     * @throws EnderecoEstoqueNaoCadastradoException
     * @throws ErroAcessoRepositorioException 
     * 
     * METODOS QUE REMOVE OS ENDEREÇOS DOS ESTOQUES
     */
    public void removerEnderecoEstoque(int idEnderecoEstoque) throws EnderecoEstoqueNaoCadastradoException, ErroAcessoRepositorioException {
        ControladorEnderecoEstoque objControladorEnderecoEstoque = new ControladorEnderecoEstoque(this.objRepositorioEnderecoEstoque);
        objControladorEnderecoEstoque.remover(idEnderecoEstoque);
    }

    /**************************************************
     ******** FIM DOS MÉTODOS DE ENDEREÇO ESTOQUE *****
     *************************************************/
    /**************************************************
     ******** INICIO DOS MÉTODOS DE FORNECEDOR *****
     *************************************************/
    /**
     * Método que ira cadastrar os Fornecedores na base
     * 
     * @param objFornecedor
     * @throws ErroAcessoRepositorioException 
     */
    public void cadastrarFornecedor(Fornecedor objFornecedor) throws ErroAcessoRepositorioException, CamposObrigatoriosException {
        ControladorFornecedor objCadastroFornecedor = new ControladorFornecedor(this.objRepositorioFornecedor);

        objCadastroFornecedor.cadastrar(objFornecedor);
    }

    /**
     * Método que ira  atualizar os Fornecedores na base
     * 
     * @param objFornecedor
     * @throws ErroAcessoRepositorioException 
     */
    public void atualizarFornecedor(Fornecedor objFornecedor) throws ErroAcessoRepositorioException, CamposObrigatoriosException {
        ControladorFornecedor objCadastroFornecedor = new ControladorFornecedor(this.objRepositorioFornecedor);

        objCadastroFornecedor.atualizar(objFornecedor);
    }

    /**
     * Método que irá procurar um determinado objeto na base
     * 
     * @param idFornecedor
     * @throws FornecedorNaoCadastradoException
     * @throws ErroAcessoRepositorioException 
     * @return Fornecedor
     */
    public Fornecedor procurarFornecedor(int idFornecedor) throws fornecedor.FornecedorNaoCadastradoException, ErroAcessoRepositorioException {
        ControladorFornecedor objCadastroFornecedor = new ControladorFornecedor(this.objRepositorioFornecedor);

        return objCadastroFornecedor.procurar(idFornecedor);
    }

    /**
     * Método que ira verificar a existência de um objeto na base
     * 
     * @param idFornecedor
     * @throws ErroAcessoRepositorioException 
     * @return boolean
     */
    public boolean existeFornecedor(int idFornecedor) throws ErroAcessoRepositorioException {
        CadastroFornecedor objCadastroFornecedor = new CadastroFornecedor(this.objRepositorioFornecedor);

        // verificando a existencia do objeto
        return objCadastroFornecedor.existe(idFornecedor);
    }

    /**
     * Método que ira listar todos os objetos da base     * 
     * 
     * @return List<Fornecedor>
     * @throws Exception
     * @throws ErroAcessoRepositorioException 
     */
    public List<Fornecedor> listarFornecedor(String strComplemento) throws Exception, ErroAcessoRepositorioException {
        ControladorFornecedor objCadastroFornecedor = new ControladorFornecedor(this.objRepositorioFornecedor);

        // listandos os objetos
        return objCadastroFornecedor.listar(strComplemento);
    }

    /**
     * Método que ira remover um determinado objeto pelo id da base
     * 
     * @param idFornecedor
     * @throws FornecedorNaoCadastradoException
     * @throws ErroAcessoRepositorioException 
     */
    public void removerFornecedor(int idFornecedor) throws FornecedorNaoCadastradoException, ErroAcessoRepositorioException {
        CadastroFornecedor objCadastroFornecedor = new CadastroFornecedor(this.objRepositorioFornecedor);

        // removendo o objeto
        objCadastroFornecedor.remover(idFornecedor);
    }
    
    /**
     * Método que ira listar os objetos Fornacedores na base pela descrição
     * 
     * @throws Exception
     * @throws ErroAcessoRepositorioException
     * @return List<Fornecedor>
     */
    public List<Fornecedor> listarFornecedorPorDescricao(String strDescricao) throws Exception, ErroAcessoRepositorioException {
        ControladorFornecedor objCadastroFornecedor = new ControladorFornecedor(this.objRepositorioFornecedor);

        // listandos os objetos
        return objCadastroFornecedor.listarPorDescricao(strDescricao);
    }

    /************************************************
     ******** FIM DOS MÉTODOS DE FORNECEDOR *********
     ************************************************/
    /*****************************************************
     ******** INICIO DOS MÉTODOS DE SUBSETOR****************
     *****************************************************/
    /**
     *
     * @param objRepositorioSubSetor
     * @throws ErroAcessoRepositorioException
     */
    public void cadastrarSubSetor(SubSetor objSubSetor) throws ErroAcessoRepositorioException, CamposObrigatoriosException {
        ControladorSubSetor objControladorSubSetor = new ControladorSubSetor(this.objRepositorioSubSetor);

        objControladorSubSetor.Cadastrar(objSubSetor);
    }

    /**
     * Metodo que ira cadastrar o SubSetor
     *
     * @param SubSetor objSubSetor
     * @return void
     */
    public void atualizarSubSetor(SubSetor objSubSetor) throws ErroAcessoRepositorioException, CamposObrigatoriosException {
        ControladorSubSetor objControladorSubSetor = new ControladorSubSetor(this.objRepositorioSubSetor);

        objControladorSubSetor.Atualizar(objSubSetor);

    }

    /**
     * Metodo que ira produrar o SubSetor
     *
     * @param int idSubSetor
     * @return void
     */
    public SubSetor procurarSubSetor(int idSubSetor) throws SubSetorNaoCadastradoException, ErroAcessoRepositorioException, CamposObrigatoriosException {
        ControladorSubSetor objControladorSubSetor = new ControladorSubSetor(this.objRepositorioSubSetor);

        return objControladorSubSetor.procurar(idSubSetor);

    }

    /**
     * Metodo que ira verificar a existência do SubSetor
     *
     * @param int idSubSetor
     * @return void
     */
    public boolean existeSubSetor(int idSubSetor) throws ErroAcessoRepositorioException, CamposObrigatoriosException {
        ControladorSubSetor objControladorSubSetor = new ControladorSubSetor(this.objRepositorioSubSetor);

        return objControladorSubSetor.existe(idSubSetor);

    }

    /**
     * Metodo que ira listar os SubSetors
     *
     * @return Collection
     */
    public List<SubSetor> listarSubSetor(String strComplemento) throws Exception, ErroAcessoRepositorioException, CamposObrigatoriosException {
        ControladorSubSetor objControladorSubSetor = new ControladorSubSetor(this.objRepositorioSubSetor);

        return objControladorSubSetor.listar(strComplemento);
    }

    /**
     * Método que ira remover o SubSetor do banco
     *
     * @param idSubSetor
     */
    public void removerSubSetor(int idSubSetor) throws SubSetorNaoCadastradoException, ErroAcessoRepositorioException, CamposObrigatoriosException {
        ControladorSubSetor objControladorSubSetor = new ControladorSubSetor(this.objRepositorioSubSetor);

        objControladorSubSetor.remover(idSubSetor);
    }
    
    /**
     * Metodo que ira listar o SubSetor
     *
     * @return Collection
     */
    public List<SubSetor> listarSubSetorAtivos() throws Exception, ErroAcessoRepositorioException {
       ControladorSubSetor objControladorSubSetor = new ControladorSubSetor(this.objRepositorioSubSetor);

       return objControladorSubSetor.listarAtivos();
    }
    
    /**
     * Metodo que ira listar os Categorias
     *
     * @return Collection
     */
    public List<SubSetor> procurarSubSetorPorDescricaoPorSetor(String descricaoSubSetor, int idSetor) throws Exception, ErroAcessoRepositorioException {
       ControladorSubSetor objControladorSubSetor = new ControladorSubSetor(this.objRepositorioSubSetor);

       return objControladorSubSetor.procurarPorDescricaoPorSetor(descricaoSubSetor, idSetor);
    }

    /*****************************************************
     ******** FIM DOS MÉTODOS DE SUBSETOR ****************
     *****************************************************/
    /*************************************************
     ********* INICIO DOS MÉTODOS DE NIVEL ***********
     *************************************************/
    /**
     * 
     * 
     * @param objNivel
     * @throws ErroAcessoRepositorioException
     * @throws CamposObrigatoriosException 
     */
    public void cadastrarNivel(Nivel objNivel) throws ErroAcessoRepositorioException, CamposObrigatoriosException {
        ControladorNivel objControladorNivel = new ControladorNivel(this.objRepositorioNivel);

        objControladorNivel.cadastrar(objNivel);
    }

    /**
     * Método que ria atualizar o objeto Nivel na Base
     * 
     * @param objNivel
     * @throws ErroAcessoRepositorioException
     * @throws CamposObrigatoriosException 
     */
    public void atualizarNivel(Nivel objNivel) throws ErroAcessoRepositorioException, CamposObrigatoriosException {
        ControladorNivel objControladorNivel = new ControladorNivel(this.objRepositorioNivel);

        objControladorNivel.atualizar(objNivel);
    }

    /**
     * Método que ira procurar um determinado objeto na báse
     * 
     * @param idNivel
     * @return Nivel
     * @throws NivelNaoCadastradoException
     * @throws ErroAcessoRepositorioException
     * @throws CamposObrigatoriosException 
     */
    public Nivel procurarNivel(int idNivel) throws NivelNaoCadastradoException, ErroAcessoRepositorioException, CamposObrigatoriosException {
        ControladorNivel objControladorNivel = new ControladorNivel(this.objRepositorioNivel);

        return objControladorNivel.procurar(idNivel);
    }

    /**
     * Método que ira verificar a existencia de um determinado obejto na base
     * 
     * @param idNivel
     * @return boolean
     * @throws ErroAcessoRepositorioException
     * @throws CamposObrigatoriosException 
     */
    public boolean existeNivel(int idNivel) throws ErroAcessoRepositorioException, CamposObrigatoriosException {
        ControladorNivel objControladorNivel = new ControladorNivel(this.objRepositorioNivel);

        return objControladorNivel.existe(idNivel);
    }

    /**
     * Método que ira listar todos os objetos da base
     * 
     * @return List<Nivel>
     * @throws Exception
     * @throws ErroAcessoRepositorioException 
     */
    public List<Nivel> listarNivel(String strComplemento) throws Exception, ErroAcessoRepositorioException {
        ControladorNivel objControladorNivel = new ControladorNivel(this.objRepositorioNivel);

        return objControladorNivel.listar(strComplemento);
    }

    /**
     * Método que ira remover m determinado objeto da base
     * 
     * @param idNivel
     * @throws NivelNaoCadastradoException
     * @throws ErroAcessoRepositorioException
     * @throws CamposObrigatoriosException 
     */
    public void removerNivel(int idNivel) throws NivelNaoCadastradoException, ErroAcessoRepositorioException, CamposObrigatoriosException {
        ControladorNivel objControladorNivel = new ControladorNivel(this.objRepositorioNivel);

        objControladorNivel.remover(idNivel);
    }

    public List<Nivel> listarNivelAtivos() throws Exception, ErroAcessoRepositorioException{
        ControladorNivel objControladorNivel = new ControladorNivel(this.objRepositorioNivel);
        
        return objControladorNivel.listarAtivos();
    }
    
    /**
     * Metodo que ira listar os Categorias
     *
     * @return Collection
     */
    public List<Nivel> procurarNivelPorDescricaoPorSubSetor(String descricaoNivel, int idSubSetor) throws Exception, ErroAcessoRepositorioException {
        ControladorNivel objControladorNivel = new ControladorNivel(this.objRepositorioNivel);
        
        return objControladorNivel.procurarPorDescricaoPorSubSetor(descricaoNivel, idSubSetor);        
    }
    
    /*************************************************
     ********* FIM DOS MÉTODOS DE NIVEL **************
     *************************************************/
    /*************************************************
     ****** INICIO DOS MÉTODOS DE STATUSPRODUTO ******
     *************************************************/
    /**
     * Método que ira cadastrar / atualizar os objetos StatusProduto da base
     * @param objStatusProduto 
     */
    public void cadastrarStatusProduto(StatusProduto objStatusProduto) throws ErroAcessoRepositorioException, CamposObrigatoriosException {
        // Iniciando os controladores
        ControladorStatusProduto objControladorStatusProduto = new ControladorStatusProduto(this.objRepositorioStatusProduto);

        objControladorStatusProduto.cadastrar(objStatusProduto);
    }

    /**
     * Método que ira cadastrar / atualizar os objetos StatusProduto da base
     * @param objStatusProduto 
     */
    public void atualizarStatusProduto(StatusProduto objStatusProduto) throws ErroAcessoRepositorioException, CamposObrigatoriosException {
        // Iniciando os controladores
        ControladorStatusProduto objControladorStatusProduto = new ControladorStatusProduto(this.objRepositorioStatusProduto);

        objControladorStatusProduto.atualizar(objStatusProduto);
    }

    /**
     * Método que ira procurar na base o status do produto pelo seu identificador
     * 
     * @param idStatusProduto
     * @return StatusProduto
     */
    public StatusProduto procurarStatusProduto(int idStatusProduto) throws ErroAcessoRepositorioException, CamposObrigatoriosException {
        // Iniciando os controladores
        ControladorStatusProduto objControladorStatusProduto = new ControladorStatusProduto(this.objRepositorioStatusProduto);

        return objControladorStatusProduto.procurar(idStatusProduto);
    }

    /**
     * Método que ira verificar a existencia de um determinado objeto na base
     * 
     * @param idStatusProduto
     * @return boolean
     */
    public boolean existeStatusProduto(int idStatusProduto) throws ErroAcessoRepositorioException, CamposObrigatoriosException {
        // Iniciando os controladores
        ControladorStatusProduto objControladorStatusProduto = new ControladorStatusProduto(this.objRepositorioStatusProduto);

        return objControladorStatusProduto.existe(idStatusProduto);
    }

    /**
     * Método que ira listar os objetos da base por uma determinada condição ou não
     * @param strComplemento
     * @return List<StatusProduto>
     */
    public List<StatusProduto> listarStatusProduto(String strComplemento) throws ErroAcessoRepositorioException {
        // Iniciando os controladores
        ControladorStatusProduto objControladorStatusProduto = new ControladorStatusProduto(this.objRepositorioStatusProduto);

        return objControladorStatusProduto.listar(strComplemento);
    }

    /**
     * Método que ira remover um objeto da base pelo seu identificador
     * 
     * @param idStatusProduto 
     */
    public void removerStatusProduto(int idStatusProduto) throws ErroAcessoRepositorioException, CamposObrigatoriosException {
        // Iniciando os controladores
        ControladorStatusProduto objControladorStatusProduto = new ControladorStatusProduto(this.objRepositorioStatusProduto);

        objControladorStatusProduto.remover(idStatusProduto);
    }

    /*************************************************
     ********* FIM DOS MÉTODOS DE STATUSPRODUTO ******
     *************************************************/
    /************************************************
     ******* FIM MÉTODOS DE EMPRESA *****************
     ************************************************/
    /**
     * Método que ira cadastrar a empresa na base
     * 
     * @param objEmpresa
     * @throws ErroAcessoRepositorioException 
     */
    public void cadastrarEmpresa(Empresa objEmpresa) throws ErroAcessoRepositorioException, CamposObrigatoriosException, Exception {
        ControladorEmpresa objControladorEmpresa = new ControladorEmpresa(this.objRepositorioEmpresa);

        objControladorEmpresa.cadastrar(objEmpresa);
    }

    /**
     * Método que ira cadastrar a empresa na base
     * 
     * @param objEmpresa
     * @throws ErroAcessoRepositorioException 
     */
    public void atualizarEmpresa(Empresa objEmpresa) throws ErroAcessoRepositorioException, CamposObrigatoriosException, Exception {
        ControladorEmpresa objControladorEmpresa = new ControladorEmpresa(this.objRepositorioEmpresa);

        objControladorEmpresa.atualizar(objEmpresa);
    }

    /**
     * Método que ira procurar uma determinada empresa na base
     * @param idEmpresa
     * @return Empresa
     * @throws ErroAcessoRepositorioException 
     */
    public Empresa procurarEmpresa(int idEmpresa) throws ErroAcessoRepositorioException {
        return this.objRepositorioEmpresa.procurar(idEmpresa);
    }

    /**
     * Método que ira verificar a existencia de uma empresa na base
     * 
     * @param idEmpresa
     * @return boolean
     * @throws ErroAcessoRepositorioException 
     */
    public boolean existeEmpresa(int idEmpresa) throws ErroAcessoRepositorioException {
        return this.objRepositorioEmpresa.existe(idEmpresa);
    }

    /**
     * Método que ira listar as empresa da base
     * 
     * @param strComplemento
     * @return List<Empresa> 
     * @throws ErroAcessoRepositorioException 
     */
    public List<Empresa> listarEmpresa(String strComplemento) throws ErroAcessoRepositorioException {
        return this.objRepositorioEmpresa.listar(strComplemento);
    }

    /**
     * Método que ira remover as empresas da base
     * 
     * @param idEmpresa
     * @throws Exception 
     */
    public void removerEmpresa(int idEmpresa) throws Exception {
        this.objRepositorioEmpresa.remover(idEmpresa);
    }

    
    public List<Empresa> listarEmpresaAtivos() throws Exception, ErroAcessoRepositorioException {
        // Iniciando os controladores
        ControladorEmpresa objControladorEmpresa = new ControladorEmpresa(this.objRepositorioEmpresa);

        // Cadastrando o objeto passado
        return objControladorEmpresa.listarAtivos();
    }

   public List<Empresa> procurarEmpresaPorDescricao(String descricao) throws Exception, ErroAcessoRepositorioException {
        // Iniciando meus cadastros
        ControladorEmpresa objControladorEmpresa = new ControladorEmpresa(this.objRepositorioEmpresa);

        return objControladorEmpresa.procurarEmpresaPorDescricao(descricao);
    }
 
    
    
    
    /************************************************
     ******* FIM MÉTODOS DE EMPRESA *****************
     ************************************************/
    /***********************************************
     ****** INICIO DOS METODOS DE SETOR EMPRESA ****
     ***********************************************/
    /**
     * Método que ira cadastrar/atualizar o SetorEmpresa na base
     * 
     * @param objSetorEmpresa
     * @throws ErroAcessoRepositorioException 
     */
    public void cadastrarSetorEmpresa(SetorEmpresa objSetorEmpresa) throws ErroAcessoRepositorioException, CamposObrigatoriosException {
        // Iniciando os cadastros
        ControladorSetorEmpresa objControladorSetorEmpresa = new ControladorSetorEmpresa(this.objRepositorioSetorEmpresa);

        objControladorSetorEmpresa.cadastrar(objSetorEmpresa);
    }

    /**
     * Método que ira cadastrar/atualizar o SetorEmpresa na base
     * 
     * @param objSetorEmpresa
     * @throws ErroAcessoRepositorioException 
     */
    public void atualizarSetorEmpresa(SetorEmpresa objSetorEmpresa) throws ErroAcessoRepositorioException, CamposObrigatoriosException {
        // Iniciando os cadastros
        ControladorSetorEmpresa objControladorSetorEmpresa = new ControladorSetorEmpresa(this.objRepositorioSetorEmpresa);

        objControladorSetorEmpresa.atualizar(objSetorEmpresa);
    }

    /**
     * Método que ira procurar uma determinada empresa na base
     * @param idSetorEmpresa
     * @return SetorEmpresa
     * @throws ErroAcessoRepositorioException 
     */
    public SetorEmpresa procurarSetorEmpresa(int idSetorEmpresa) throws ErroAcessoRepositorioException, CamposObrigatoriosException {
        // Iniciando os cadastros
        ControladorSetorEmpresa objControladorSetorEmpresa = new ControladorSetorEmpresa(this.objRepositorioSetorEmpresa);

        return objControladorSetorEmpresa.procurar(idSetorEmpresa);
    }

    /**
     * Método que ira verificar a existencia de uma empresa na base
     * 
     * @param idSetorEmpresa
     * @return boolean
     * @throws ErroAcessoRepositorioException 
     */
    public boolean existeSetorEmpresa(int idSetorEmpresa) throws ErroAcessoRepositorioException, CamposObrigatoriosException {
        // Iniciando os cadastros
        ControladorSetorEmpresa objControladorSetorEmpresa = new ControladorSetorEmpresa(this.objRepositorioSetorEmpresa);

        return objControladorSetorEmpresa.existe(idSetorEmpresa);
    }

    /**
     * Método que ira listar as empresa da base
     * 
     * @param strComplemento
     * @return List<SetorEmpresa> 
     * @throws ErroAcessoRepositorioException 
     */
    public List<SetorEmpresa> listarSetorEmpresa(String strDescricao) throws ErroAcessoRepositorioException {
        // Iniciando os cadastros
        ControladorSetorEmpresa objControladorSetorEmpresa = new ControladorSetorEmpresa(this.objRepositorioSetorEmpresa);

        return objControladorSetorEmpresa.listar(strDescricao);
    }

    /**
     * Método que ira remover as empresas da base
     * 
     * @param idSetorEmpresa
     * @throws Exception 
     */
    public void removerSetorEmpresa(int idSetorEmpresa) throws Exception {
        // Iniciando os cadastros
        ControladorSetorEmpresa objControladorSetorEmpresa = new ControladorSetorEmpresa(this.objRepositorioSetorEmpresa);

        objControladorSetorEmpresa.remover(idSetorEmpresa);
    }
    
    /**
     * Método que lista Os SETOR empresas pela sua descrição
     * 
     * @param descricaoEmpresa
     * @return List<Empresa>
     * @throws Exception
     * @throws ErroAcessoRepositorioException 
     */
    public List<SetorEmpresa> listarSetorEmpresaPorDescricao(String descricaoSetorEmpresa) throws Exception {
        // Iniciando os cadastros
        ControladorSetorEmpresa objControladorSetorEmpresa = new ControladorSetorEmpresa(this.objRepositorioSetorEmpresa);

        return objControladorSetorEmpresa.listarSetorEmpresa(descricaoSetorEmpresa);
    }

    /***********************************************
     ******  FIM DOS MÉTODOS DE SETOR EMPRESA ******
     ***********************************************/
    /**********************************************
     **** INICIO DOS MÉTODOS DE CARGO *************
     **********************************************/
    /**
     * Metodo que ira cadastrar/atualizar os objetos Cargo
     * 
     * @param objCargo
     * @throws ErroAcessoRepositorioException 
     */
    public void cadastrarCargo(Cargo objCargo) throws ErroAcessoRepositorioException, CamposObrigatoriosException {
        // Iniciando meus cadastros
        ControladorCargo objControladorCargo = new ControladorCargo(this.objRepositorioCargo);

        objControladorCargo.cadastrar(objCargo);
    }

    /**
     * Metodo que ira cadastrar/atualizar os objetos Cargo
     * 
     * @param objCargo
     * @throws ErroAcessoRepositorioException 
     */
    public void atualizarCargo(Cargo objCargo) throws ErroAcessoRepositorioException, CamposObrigatoriosException {
        // Iniciando meus cadastros
        ControladorCargo objControladorCargo = new ControladorCargo(this.objRepositorioCargo);

        objControladorCargo.atualizar(objCargo);
    }

    /**
     * Método que ira procurar um determinado objeto Cargo na base pelo seu Id
     * 
     * @param idCargo
     * @throws Exception
     * @throws ErroAcessoRepositorioException 
     * @return Cargo
     */
    public Cargo procurarCargo(int idCargo) throws ErroAcessoRepositorioException, Exception, CamposObrigatoriosException {
        // Iniciando meus cadastros
        ControladorCargo objControladorCargo = new ControladorCargo(this.objRepositorioCargo);

        return objControladorCargo.procurar(idCargo);
    }

    /**
     * Método que ira verificar a existência da um objeto Cargo
     * @param idCargo
     * @throws ErroAcessoRepositorioException 
     * @return boolean
     */
    public boolean existeCargo(int idCargo) throws ErroAcessoRepositorioException, CamposObrigatoriosException {
        // Iniciando meus cadastros
        ControladorCargo objControladorCargo = new ControladorCargo(this.objRepositorioCargo);

        return objControladorCargo.existe(idCargo);
    }

    /**
     * Método que ira listar os objetos Cargo na case
     * 
     * @return List<Cargo>
     * @throws Exception
     * @throws ErroAcessoRepositorioException 
     */
    public List<Cargo> listarCargo(String strComplemento) throws Exception, ErroAcessoRepositorioException {
        // Iniciando meus cadastros
        ControladorCargo objControladorCargo = new ControladorCargo(this.objRepositorioCargo);

        return objControladorCargo.listar(strComplemento);
    }

    /**
     * Método que ira listar os objetos Cargo na case
     * 
     * @return List<Cargo>
     * @throws Exception
     * @throws ErroAcessoRepositorioException 
     */
    public List<Cargo> procurarCargoPorDescricao(String descricao) throws Exception, ErroAcessoRepositorioException {
        // Iniciando meus cadastros
        ControladorCargo objControladorCargo = new ControladorCargo(this.objRepositorioCargo);

        return objControladorCargo.procurarPorDescricao(descricao);
    }

    /**
     * Método que ira remover um objeto Cargo da base
     * 
     * @param idCargo
     * @throws CargoNaoCadastradoException
     * @throws ErroAcessoRepositorioException 
     */
    public void removerCargo(int idCargo) throws Exception, ErroAcessoRepositorioException, CamposObrigatoriosException {
        // Iniciando meus cadastros
        ControladorCargo objControladorCargo = new ControladorCargo(this.objRepositorioCargo);

        objControladorCargo.remover(idCargo);
    }

    /**********************************************
     ******* FIM DOS MÉTODOS DE CARGO *************
     **********************************************/
    /*********************************************
     ****** INICIO DOS MÉTODOS DE PERMISSAO ****** 
     *********************************************/
    /**
     * Metodo que ira cadastrar/atualizar os objetos Permissao
     * 
     * @param objPermissao
     * @throws ErroAcessoRepositorioException 
     */
    public void cadastrarPermissao(Permissao objPermissao) throws ErroAcessoRepositorioException, CamposObrigatoriosException {
        // Iniciando os cadastros
        ControladorPermissao objControladorPermissao = new ControladorPermissao(this.objRepositorioPermissao);

        objControladorPermissao.cadastrar(objPermissao);
    }

    /**
     * Metodo que ira cadastrar/atualizar os objetos Permissao
     * 
     * @param objPermissao
     * @throws ErroAcessoRepositorioException 
     */
    public void atualizarPermissao(Permissao objPermissao) throws ErroAcessoRepositorioException, CamposObrigatoriosException {
        // Iniciando os cadastros
        ControladorPermissao objControladorPermissao = new ControladorPermissao(this.objRepositorioPermissao);

        objControladorPermissao.atualizar(objPermissao);
    }

    /**
     * Método que ira procurar um determinado objeto Permissao na base pelo seu Id
     * 
     * @param idPermissao
     * @throws Exception
     * @throws ErroAcessoRepositorioException 
     * @return Permissao
     */
    public Permissao procurarPermissao(int idPermissao) throws ErroAcessoRepositorioException, CamposObrigatoriosException, Exception {
        // Iniciando os cadastros
        ControladorPermissao objControladorPermissao = new ControladorPermissao(this.objRepositorioPermissao);

        return objControladorPermissao.procurar(idPermissao);
    }

    /**
     * Método que ira verificar a existência da um objeto Permissao
     * @param idPermissao
     * @throws ErroAcessoRepositorioException 
     * @return boolean
     */
    public boolean existePermissao(int idPermissao) throws ErroAcessoRepositorioException, CamposObrigatoriosException {
        // Iniciando os cadastros
        ControladorPermissao objControladorPermissao = new ControladorPermissao(this.objRepositorioPermissao);

        return objControladorPermissao.existe(idPermissao);
    }

    /**
     * Método que ira listar os objetos Permissao na case
     * 
     * @return List<Permissao>
     * @throws Exception
     * @throws ErroAcessoRepositorioException 
     */
    public List<Permissao> listarPermissao(String strComplemento) throws Exception, ErroAcessoRepositorioException {
        // Iniciando os cadastros
        ControladorPermissao objControladorPermissao = new ControladorPermissao(this.objRepositorioPermissao);

        return objControladorPermissao.listar(strComplemento);
    }

    public List<Permissao> listarPermissaoPorLogin(int idLogin) throws Exception, ErroAcessoRepositorioException {
        // Iniciando os cadastros
        ControladorPermissao objControladorPermissao = new ControladorPermissao(this.objRepositorioPermissao);

        return objControladorPermissao.listarPermissaoPorLogin(idLogin);
    }

    /**
     * Método que ira remover um objeto Permissao da base
     * 
     * @param idPermissao
     * @throws PermissaoNaoCadastradoException
     * @throws ErroAcessoRepositorioException 
     */
    public void removerPermissao(int idPermissao) throws Exception, ErroAcessoRepositorioException {
        // Iniciando os cadastros
        ControladorPermissao objControladorPermissao = new ControladorPermissao(this.objRepositorioPermissao);

        objControladorPermissao.remover(idPermissao);
    }
    
    /**
     * Método que ira listar as permissões pela descrição
     * 
     * @param strDescricao
     * @return
     * @throws Exception
     * @throws ErroAcessoRepositorioException 
     */
    public List<Permissao> listarPermissaoPorDescricao(String strDescricao) throws Exception {
        // Iniciando os cadastros
        ControladorPermissao objControladorPermissao = new ControladorPermissao(this.objRepositorioPermissao);

        return objControladorPermissao.listarPermissaoPorDescricao(strDescricao);
    }        

    /***********************************************
     ******** FIM DOS MÉTODOS DE PERMISSAO
     ***********************************************/
    /**********************************************
     ******* INICIO DOS METODOS DE FUNCIONARIO *** 
     *********************************************/
    /**
     * Método que ira cadastrar a Funcionario na base
     * 
     * @param objFuncionario
     * @throws ErroAcessoRepositorioException 
     */
    public void cadastrarFuncionario(Funcionario objFuncionario) throws ErroAcessoRepositorioException, CamposObrigatoriosException, CamposInvalidosException, Exception {
        // iniciando meus cadastros   
        ControladorFuncionario objControladorFuncionario = new ControladorFuncionario(this.objRepositorioFuncionario);

        objControladorFuncionario.cadastrar(objFuncionario);
    }

    /**
     * Método que ira cadastrar a Funcionario na base
     * 
     * @param objFuncionario
     * @throws ErroAcessoRepositorioException 
     */
    public void atualizarFuncionario(Funcionario objFuncionario) throws ErroAcessoRepositorioException, CamposObrigatoriosException, CamposInvalidosException, Exception {
        // iniciando meus cadastros   
        ControladorFuncionario objControladorFuncionario = new ControladorFuncionario(this.objRepositorioFuncionario);

        objControladorFuncionario.atualizar(objFuncionario);
    }

    /**
     * Método que ira procurar uma determinada Funcionario na base
     * @param idFuncionario
     * @return Funcionario
     * @throws ErroAcessoRepositorioException 
     */
    public Funcionario procurarFuncionario(int idFuncionario) throws ErroAcessoRepositorioException, CamposObrigatoriosException, Exception {
        // iniciando meus cadastros   
        ControladorFuncionario objControladorFuncionario = new ControladorFuncionario(this.objRepositorioFuncionario);
        
        return objControladorFuncionario.procurar(idFuncionario);
    }

    /**
     * Método que ira verificar a existencia de uma Funcionario na base
     * 
     * @param idFuncionario
     * @return boolean
     * @throws ErroAcessoRepositorioException 
     */
    public boolean existeFuncionario(int idFuncionario) throws ErroAcessoRepositorioException, CamposObrigatoriosException {
        // iniciando meus cadastros   
        ControladorFuncionario objControladorFuncionario = new ControladorFuncionario(this.objRepositorioFuncionario);

        return objControladorFuncionario.existe(idFuncionario);

    }

    /**
     * Método que ira listar as Funcionario da base
     * 
     * @param strComplemento
     * @return List<Funcionario> 
     * @throws ErroAcessoRepositorioException 
     */
    public List<Funcionario> listarFuncionario(String strComplemento) throws ErroAcessoRepositorioException {
        // iniciando meus cadastros   
        ControladorFuncionario objControladorFuncionario = new ControladorFuncionario(this.objRepositorioFuncionario);

        return objControladorFuncionario.listar(strComplemento);
    }

    /**
     * Método que ira remover as Funcionarios da base
     * 
     * @param idFuncionario
     * @throws Exception 
     */
    public void removerFuncionario(int idFuncionario) throws Exception, CamposObrigatoriosException {
        // iniciando meus cadastros   
        ControladorFuncionario objControladorFuncionario = new ControladorFuncionario(this.objRepositorioFuncionario);

        objControladorFuncionario.remover(idFuncionario);
    }
    
    /**
     * Método que ira listar as Funcionario da base
     * 
     * @param strComplemento
     * @return List<Funcionario> 
     * @throws ErroAcessoRepositorioException 
     */
    public Funcionario procurarFuncionarioPorLogin(String strLogin) throws ErroAcessoRepositorioException, CamposObrigatoriosException {
        // iniciando meus cadastros   
        ControladorFuncionario objControladorFuncionario = new ControladorFuncionario(this.objRepositorioFuncionario);

        return objControladorFuncionario.procurarPorLogin(strLogin);
    }
    
     /**
     * Método que ira buscar o Funcionario pelo seu Login e senha na base
     * 
     * @param strLogin
     * @param strSenha
     * @return Funcionario objFuncionario
     * @throws ErroAcessoRepositorioException 
     */
    public Funcionario procurarFuncionarioPorLoginPorSenha(String strLogin, String strSenha) throws Exception {
         // iniciando meus cadastros   
        ControladorFuncionario objControladorFuncionario = new ControladorFuncionario(this.objRepositorioFuncionario);

        return objControladorFuncionario.procurarPorLoginPorSenha(strLogin, strSenha);
    }
     /**
     * Método que ira listar as Funcionario da base
     * 
     * @param strComplemento
     * @return List<Funcionario> 
     * @throws ErroAcessoRepositorioException 
     */
    public List<Funcionario> listarAtivos() throws ErroAcessoRepositorioException {
        // iniciando meus cadastros   
        ControladorFuncionario objControladorFuncionario = new ControladorFuncionario(this.objRepositorioFuncionario);

        return objControladorFuncionario.listarAtivos();
    }

    /******************************************
     **** FIM DOS MÉTODOS DE FUNCIONÁRIO *****
     *****************************************/
    /*****************************************************
     ******** INICIO DOS METODOS DE SOLICITACAOCOMPRA **** 
     *****************************************************/
    /**
     * Método que ira cadastrar  o objeto Solicitacao compra
     * 
     * @param objSolicitacaoCompra
     * @throws ErroAcessoRepositorioException 
     */
    public void cadastrarSolicitacaoCompra(SolicitacaoCompra objSolicitacaoCompra) throws ErroAcessoRepositorioException, CamposObrigatoriosException {
        ControladorSolicitacaoCompra objControladorSolicitacaoCompra = new ControladorSolicitacaoCompra(this.objRepositorioSolicitacaoCompra);

        objControladorSolicitacaoCompra.cadastrar(objSolicitacaoCompra);
    }

    /**
     * Método que ira atualizar o objeto Solicitacao compra
     * 
     * @param objSolicitacaoCompra
     * @throws ErroAcessoRepositorioException 
     */
    public void atualizarSolicitacaoCompra(SolicitacaoCompra objSolicitacaoCompra) throws ErroAcessoRepositorioException, CamposObrigatoriosException {
        ControladorSolicitacaoCompra objControladorSolicitacaoCompra = new ControladorSolicitacaoCompra(this.objRepositorioSolicitacaoCompra);

        objControladorSolicitacaoCompra.atualizar(objSolicitacaoCompra);
    }

    /**
     * Método que ira procurar na base um objeto solicitação compra pelo seu id
     * 
     * @param idSolicitacaoCompra
     * @return  SolicitacaoCompra
     * @throws ErroAcessoRepositorioException
     */
    public SolicitacaoCompra procurarSolicitacaoCompra(int idSolicitacaoCompra) throws ErroAcessoRepositorioException, CamposObrigatoriosException {
        ControladorSolicitacaoCompra objControladorSolicitacaoCompra = new ControladorSolicitacaoCompra(this.objRepositorioSolicitacaoCompra);

        return objControladorSolicitacaoCompra.procurar(idSolicitacaoCompra);
    }

    /**
     * Método que ira verificar a existencia na base um objeto solicitação compra pelo seu id
     * 
     * @param idSolicitacaoCompra
     * @return  boolean
     */
    public boolean existeSolicitacaoCompra(int idSolicitacaoCompra) throws ErroAcessoRepositorioException, CamposObrigatoriosException {
        ControladorSolicitacaoCompra objControladorSolicitacaoCompra = new ControladorSolicitacaoCompra(this.objRepositorioSolicitacaoCompra);

        return objControladorSolicitacaoCompra.existe(idSolicitacaoCompra);
    }

    /**
     * método que ira listar os objetos na base
     * @param strComplemento
     * @return  List<SolicitacaoCompra>
     */
    public List<SolicitacaoCompra> listarSolicitacaoCompra(String strComplemento) {
        ControladorSolicitacaoCompra objControladorSolicitacaoCompra = new ControladorSolicitacaoCompra(this.objRepositorioSolicitacaoCompra);

        return objControladorSolicitacaoCompra.listar(strComplemento);
    }

    /**
     * 
     * @param idSolicitacaoCompra 
     */
    public void removerSolicitacaoCompra(int idSolicitacaoCompra) throws Exception, CamposObrigatoriosException {
        ControladorSolicitacaoCompra objControladorSolicitacaoCompra = new ControladorSolicitacaoCompra(this.objRepositorioSolicitacaoCompra);

        objControladorSolicitacaoCompra.remover(idSolicitacaoCompra);
    }
    
    /**
     * método que ira listar as solicitações ativas e que não houveram compras para as mesmas na base
     * @param strComplemento
     * @return  List<SolicitacaoCompra>
     */
    public List<SolicitacaoCompra> listarSolicitacaoAtivasNaoComppradas(){
        ControladorSolicitacaoCompra objControladorSolicitacaoCompra = new ControladorSolicitacaoCompra(this.objRepositorioSolicitacaoCompra);

        return objControladorSolicitacaoCompra.listarAtivasNaoComppradas();
    }
    
    /**
     * método que ira listar os objetos na base
     * @param strComplemento
     * @return  List<SolicitacaoCompra>
     */
    public List<SolicitacaoCompra> listarPordescricaoProduto(int intDescricaoProduto) throws CamposObrigatoriosException{
        ControladorSolicitacaoCompra objControladorSolicitacaoCompra = new ControladorSolicitacaoCompra(this.objRepositorioSolicitacaoCompra);

        return objControladorSolicitacaoCompra.listarPordescricaoProduto(intDescricaoProduto);
    }

    /*****************************************************
     ******** FIM DOS METODOS DE SOLICITACAOCOMPRA **** 
     *****************************************************/
    /*****************************************************
     ******** INICIO DOS METODOS DE UNIDADEMEDIDA **** 
     *****************************************************/
    /**
     * Método que ira cadastrar  o objeto Unidade de Medida
     * 
     * @param objUnidadeMedida
     * @throws ErroAcessoRepositorioException 
     */
    public void cadastrarUnidadeMedida(UnidadeMedida objUnidadeMedida) throws ErroAcessoRepositorioException, CamposObrigatoriosException {
        ControladorUnidadeMedida objControladorUnidadeMedida = new ControladorUnidadeMedida(this.objRepositorioUnidadeMedida);

        objControladorUnidadeMedida.Cadastrar(objUnidadeMedida);
    }

    /**
     * Método que ira atualizar o objeto Solicitacao compra
     * 
     * @param objUnidadeMedida
     * @throws ErroAcessoRepositorioException 
     */
    public void atualizarUnidadeMedida(UnidadeMedida objUnidadeMedida) throws ErroAcessoRepositorioException, CamposObrigatoriosException {
        ControladorUnidadeMedida objControladorUnidadeMedida = new ControladorUnidadeMedida(this.objRepositorioUnidadeMedida);

        objControladorUnidadeMedida.Atualizar(objUnidadeMedida);
    }

    /**
     * Método que ira procurar na base um objeto solicitação compra pelo seu id
     * 
     * @param idUnidadeMedida
     * @return  UnidadeMedida
     * @throws ErroAcessoRepositorioException
     */
    public UnidadeMedida procurarUnidadeMedida(int idUnidadeMedida) throws ErroAcessoRepositorioException, CamposObrigatoriosException, UnidadeMedidaNaoCadastradoException {
        ControladorUnidadeMedida objControladorUnidadeMedida = new ControladorUnidadeMedida(this.objRepositorioUnidadeMedida);

        return objControladorUnidadeMedida.procurar(idUnidadeMedida);
    }

    /**
     * Método que ira verificar a existencia na base um objeto solicitação compra pelo seu id
     * 
     * @param idUnidadeMedida
     * @return  boolean
     */
    public boolean existeUnidadeMedida(int idUnidadeMedida) throws ErroAcessoRepositorioException, CamposObrigatoriosException {
        ControladorUnidadeMedida objControladorUnidadeMedida = new ControladorUnidadeMedida(this.objRepositorioUnidadeMedida);

        return objControladorUnidadeMedida.existe(idUnidadeMedida);
    }

    /**
     * método que ira listar os objetos na base
     * @param strComplemento
     * @return  List<UnidadeMedida>
     */
    public List<UnidadeMedida> listarUnidadeMedida(String strComplemento) throws Exception {
        ControladorUnidadeMedida objControladorUnidadeMedida = new ControladorUnidadeMedida(this.objRepositorioUnidadeMedida);

        return objControladorUnidadeMedida.listar(strComplemento);
    }

    /**
     * 
     * @param idUnidadeMedida 
     */
    public void removerUnidadeMedida(int idUnidadeMedida) throws Exception, CamposObrigatoriosException {
        ControladorUnidadeMedida objControladorUnidadeMedida = new ControladorUnidadeMedida(this.objRepositorioUnidadeMedida);

        objControladorUnidadeMedida.remover(idUnidadeMedida);
    }

    /*****************************************************
     ******** FIM DOS METODOS DE UNIDADEMEDIDA **** 
     *****************************************************/
    /****************************************************
     ******* INICIO DOS MÉTODOS DE COMPRA ***************
     ****************************************************/
    /**
     * Método que ira cadastrar a Compra na base
     * 
     * @param objCompra
     * @throws ErroAcessoRepositorioException 
     */
    public void cadastrarCompra(Compra objCompra) throws ErroAcessoRepositorioException, CamposObrigatoriosException {
        ControladorCompra objControladorCompra = new ControladorCompra(this.objRepositorioCompra);
        // Cadastrando a compra
        objControladorCompra.cadastrar(objCompra);
        
        // atualizando a solicitação compra
        objCompra.getSolicitacaoCompra().setFlagComprado(true);
        // atualizando na base
        this.atualizarSolicitacaoCompra(objCompra.getSolicitacaoCompra());
    }

    /**
     * Método que ira cadastrar a Compra na base
     * 
     * @param objCompra
     * @throws ErroAcessoRepositorioException 
     */
    public void atualizarCompra(Compra objCompra) throws ErroAcessoRepositorioException, CamposObrigatoriosException {
        ControladorCompra objControladorCompra = new ControladorCompra(this.objRepositorioCompra, this.objRepositorioSolicitacaoCompra);

        objControladorCompra.atualizar(objCompra);
    }

    /**
     * Método que ira procurar uma determinada Compra na base
     * @param idCompra
     * @return Compra
     * @throws ErroAcessoRepositorioException 
     */
    public Compra procurarCompra(int idCompra) throws ErroAcessoRepositorioException, CamposObrigatoriosException {
        ControladorCompra objControladorCompra = new ControladorCompra(this.objRepositorioCompra);

        return objControladorCompra.procurar(idCompra);
    }

    /**
     * Método que ira verificar a existencia de uma Compra na base
     * 
     * @param idCompra
     * @return boolean
     * @throws ErroAcessoRepositorioException 
     */
    public boolean existeCompra(int idCompra) throws ErroAcessoRepositorioException, CamposObrigatoriosException {
        ControladorCompra objControladorCompra = new ControladorCompra(this.objRepositorioCompra);

        return objControladorCompra.existe(idCompra);
    }

    /**
     * Método que ira listar as Compra da base
     * 
     * @param strComplemento
     * @return List<Compra> 
     * @throws ErroAcessoRepositorioException 
     */
    public List<Compra> listarCompra(String strComplemento) throws ErroAcessoRepositorioException {
        ControladorCompra objControladorCompra = new ControladorCompra(this.objRepositorioCompra);

        return objControladorCompra.listar(strComplemento);
    }

    /**
     * Método que ira remover as Compras da base
     * 
     * @param idCompra
     * @throws Exception 
     */
    public void removerCompra(int idCompra) throws Exception, CamposObrigatoriosException {
        ControladorCompra objControladorCompra = new ControladorCompra(this.objRepositorioCompra);

        objControladorCompra.remover(idCompra);
    }
    
    /**
     * Método que ira listar as Compra da base
     * 
     * @param strComplemento
     * @return List<Compra> 
     * @throws ErroAcessoRepositorioException 
     */
    public List<Compra> listarComprasAtivas() throws ErroAcessoRepositorioException {
        ControladorCompra objControladorCompra = new ControladorCompra(this.objRepositorioCompra);

        return objControladorCompra.listarAtivas();
    }
    
    public List<Compra> listarCompraPorFornecedorPorSolicitacaoPorFuncionarioPorData(int idFornecedor, int idSolicitacaoCompra, int idFuncionario, Date dataSolicitacaoInicial, Date dataSolicitacaoFinal)  throws ErroAcessoRepositorioException, Exception {
        ControladorCompra objControladorCompra = new ControladorCompra(this.objRepositorioCompra);

        return objControladorCompra.listarCompraPorFornecedorPorSolicitacaoPorFuncionarioPorData(idFornecedor, idSolicitacaoCompra, idFuncionario, dataSolicitacaoInicial, dataSolicitacaoFinal);
    }
    
    /**
     * Método que ira listar as Compra da base
     * 
     * @param strComplemento
     * @return List<Compra> 
     * @throws ErroAcessoRepositorioException 
     */
    public List<Compra> listarCompraAtivasENaoRecebidas() throws ErroAcessoRepositorioException {
        ControladorCompra objControladorCompra = new ControladorCompra(this.objRepositorioCompra);

        return objControladorCompra.listarAtivasENaoRecebidas();
    }

    /*****************************************************
     ************* FIM DOS MÉTODOS COMPRA  ***************
     *****************************************************/
   
    
    /****************************************************
     ******* INICIO DOS MÉTODOS DE PERMISSAOUSUARIO ***************
     ****************************************************/
    /**
     * Método que ira cadastrar a PermissaoUsuario na base
     * 
     * @param objPermissaoUsuario
     * @throws ErroAcessoRepositorioException 
     */
    public void cadastrarPermissaoUsuario(PermissaoUsuario objPermissaoUsuario) throws ErroAcessoRepositorioException, CamposObrigatoriosException, PermissaoUsuarioJaCadastradoException {
        ControladorPermissaoUsuario objControladorPermissaoUsuario = new ControladorPermissaoUsuario(this.objRepositorioPermissaoUsuario);
        
        objControladorPermissaoUsuario.cadastrar(objPermissaoUsuario);
    }

    /**
     * Método que ira cadastrar a PermissaoUsuario na base
     * 
     * @param objPermissaoUsuario
     * @throws ErroAcessoRepositorioException 
     */
    public void atualizarPermissaoUsuario(PermissaoUsuario objPermissaoUsuario) throws ErroAcessoRepositorioException, CamposObrigatoriosException, PermissaoUsuarioJaCadastradoException {
        ControladorPermissaoUsuario objControladorPermissaoUsuario = new ControladorPermissaoUsuario(this.objRepositorioPermissaoUsuario);

        objControladorPermissaoUsuario.atualizar(objPermissaoUsuario);
    }

    /**
     * Método que ira procurar uma determinada PermissaoUsuario na base
     * @param idPermissaoUsuario
     * @return PermissaoUsuario
     * @throws ErroAcessoRepositorioException 
     */
    public PermissaoUsuario procurarPermissaoUsuario(int idPermissaoUsuario) throws ErroAcessoRepositorioException, CamposObrigatoriosException, Exception {
        ControladorPermissaoUsuario objControladorPermissaoUsuario = new ControladorPermissaoUsuario(this.objRepositorioPermissaoUsuario);

        return objControladorPermissaoUsuario.procurar(idPermissaoUsuario);
    }

    /**
     * Método que ira verificar a existencia de uma PermissaoUsuario na base
     * 
     * @param idPermissaoUsuario
     * @return boolean
     * @throws ErroAcessoRepositorioException 
     */
    public boolean existePermissaoUsuario(int idPermissaoUsuario) throws ErroAcessoRepositorioException, CamposObrigatoriosException {
        ControladorPermissaoUsuario objControladorPermissaoUsuario = new ControladorPermissaoUsuario(this.objRepositorioPermissaoUsuario);

        return objControladorPermissaoUsuario.existe(idPermissaoUsuario);
    }

    /**
     * Método que ira listar as PermissaoUsuario da base
     * 
     * @param strComplemento
     * @return List<PermissaoUsuario> 
     * @throws ErroAcessoRepositorioException 
     */
    public List<PermissaoUsuario> listarPermissaoUsuario(String strComplemento) throws ErroAcessoRepositorioException, Exception {
        ControladorPermissaoUsuario objControladorPermissaoUsuario = new ControladorPermissaoUsuario(this.objRepositorioPermissaoUsuario);

        return objControladorPermissaoUsuario.listar(strComplemento);
    }

    /**
     * Método que ira remover as PermissaoUsuarios da base
     * 
     * @param idPermissaoUsuario
     * @throws Exception 
     */
    public void removerPermissaoUsuario(int idPermissaoUsuario) throws Exception, CamposObrigatoriosException {
        ControladorPermissaoUsuario objControladorPermissaoUsuario = new ControladorPermissaoUsuario(this.objRepositorioPermissaoUsuario);

        objControladorPermissaoUsuario.remover(idPermissaoUsuario);
    }
    
    public List<PermissaoUsuario> listarPermissaoUsuarioPorLogin(int idLogin) throws ErroAcessoRepositorioException, Exception {
        ControladorPermissaoUsuario objControladorPermissaoUsuario = new ControladorPermissaoUsuario(this.objRepositorioPermissaoUsuario);

        return objControladorPermissaoUsuario.listarPorLogin(idLogin);
    }
    
    /*****************************************************
     ************* FIM DOS MÉTODOS PermissaoUsuario  ******
     *****************************************************/
    
    
    /*********************************************
     ******* INICIO DO MÉTODOS DE ENTRADA
     *********************************************/
    
    public void cadastrarEntrada(Entrada objEntrada) throws Exception{
        ControladorEntrada objControladorEntrada = new ControladorEntrada(this.objRepositorioEntrada);
        
        objControladorEntrada.inserirEntrada(objEntrada);
    }
    
    /**
     * Método que ira cancelar a entrada de materiais na base
     * 
     * @param objEntrada
     * @return int idEntrada
     * @throws Exception 
     */
    public int cancelarEntrada(Entrada objEntrada) throws Exception{
        ControladorEntrada objControladorEntrada = new ControladorEntrada(this.objRepositorioEntrada);
        
        return objControladorEntrada.cancelarEntrada(objEntrada);
    }
    
    /**
     * List<Entrada>
     * 
     * @return 
     */
    public List<Entrada> listarEntradas() throws Exception{
        ControladorEntrada objControladorEntrada = new ControladorEntrada(this.objRepositorioEntrada);
        
        return objControladorEntrada.listarEntradas();
    }
    
     /**
     * Método que ira buscar a entrada na base pelo seu Identificador
     * 
     * @param idEntrada
     * @return Entrada
     * @throws Exception 
     */
    public Entrada procurarEntrada(int idEntrada)throws Exception{
        ControladorEntrada objControladorEntrada = new ControladorEntrada(this.objRepositorioEntrada);
        
        return objControladorEntrada.procurarEntrada(idEntrada);
    }
    
    /**
     * Metodo que ira listar os Categorias
     *
     * @return Collection
     */
    public List<Entrada> listarEntradaPorFornecedorPorFuncionarioPorData(int idFornecedor, int idFuncionario, Date dataInicial, Date dataFinal) throws Exception {
        ControladorEntrada objControladorEntrada = new ControladorEntrada(this.objRepositorioEntrada);
        
        return objControladorEntrada.listarPorFornecedorPorFuncionarioPorData(idFornecedor, idFuncionario, dataInicial, dataFinal);
    }
    
    /*********************************************
     ******* FIM DO MÉTODOS DE ENTRADA
     *********************************************/
}